home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 85 / CD Temático 40 Febrero 2004.iso / DOS / ntfs / dos / hdaccess.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-15  |  13.9 KB  |  544 lines
  1. /*
  2.  
  3.     File: hdaccess.c
  4.  
  5.     Copyright (C) 1998-2001  Christophe Grenier <grenier@nef.esiea.fr>
  6.   
  7.     This software is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation; either version 2 of the License, or
  10.     (at your option) any later version.
  11.   
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.   
  17.     You should have received a copy of the GNU General Public License
  18.     along with this program; if not, write to the Free Software
  19.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  
  21.  */
  22.  
  23. #define LINUX_WRITE 1
  24. #ifdef LINUX_WRITE
  25. #define open_mode O_RDWR
  26. #else
  27. #define open_mode O_RDONLY
  28. #endif
  29. #ifdef DJGPP
  30. #include <stdlib.h>     /* atexit */
  31. #include <stdio.h>
  32. #include <go32.h>       /* dosmemget/put */
  33. #include <dpmi.h>
  34. #include <bios.h>       /* bios_k* */
  35. #include "types.h"
  36. #include "common.h"
  37. #include "fnctdsk.h"
  38. #include "hdaccess.h"
  39. //#include "interface.h"
  40. #define HD_RW_BUF_SIZ 0x10
  41. #define HDPARM_BUF_SIZ 0x1A
  42. #define MAX_IO_NBR 10
  43. #define PARA_CMD         8
  44. int hd_super(int, t_param_disk_cst, int, int, int, int, void*);
  45. int hd_identify_bios(t_param_disk param_disk);
  46. int hd_identify_enh_bios(t_param_disk param_disk);
  47. int check_enh_bios(t_param_disk param_disk, const int debug);
  48. static int dos_segment = 0;
  49. static int dos_selector = 0;
  50.  
  51. void free_dos_buffer(void)
  52. {
  53.   __dpmi_free_dos_memory(dos_selector);
  54.   dos_segment = dos_selector = 0;
  55. }
  56.  
  57. int alloc_dos_buffer(void)
  58. {
  59.   if (dos_segment)
  60.     return 0;
  61.   if ((dos_segment = __dpmi_allocate_dos_memory(18*512/16, &dos_selector))== -1)
  62.   {
  63.     dos_segment = 0;
  64.     return 1;
  65.   }
  66.   atexit(free_dos_buffer);
  67.   return 0;
  68. }
  69.  
  70. int hd_super(int cmd, t_param_disk_cst disk_car, int head, int track, int sector, int nsects, void *buffer)
  71. { 
  72.   __dpmi_regs r;
  73.   uchar buf[HD_RW_BUF_SIZ];
  74.   int dos_segment2, dos_selector2, xfer2=nsects*512;
  75. #ifdef DEBUG
  76.   printf("hd_super cmd=%d track=%d head=%d sector=%d\n",cmd,track,head,sector);
  77. #endif
  78.   if(disk_car->mode==0)
  79.   { // Limite CHS= 1023,255,63 = 8,064Mo ~= 7.8 Go
  80.     if(track<1024)
  81.       return biosdisk(cmd, disk_car->disk, head, track, sector, nsects, buffer);
  82.     return 1;
  83.   }
  84.   if(dos_segment==0)
  85.     if(alloc_dos_buffer())
  86.       return 1;
  87.   if ( (dos_segment2=__dpmi_allocate_dos_memory((xfer2 + 15) >> 4, &dos_selector2)) == -1 )
  88.     return 1;
  89.   *(word*)&buf[0]=HD_RW_BUF_SIZ;
  90.   *(word*)&buf[2]=nsects;
  91.   *(dword*)&buf[0x4]=dos_segment2<<16;
  92.   *(dword*)&buf[0x8]=(track*(disk_car->CHS.head+1)+head)* disk_car->CHS.sector+sector-1;
  93.   *(dword*)&buf[0xC]=0;
  94.  
  95.   r.x.ds = dos_segment;
  96.   r.x.si = 0;
  97.   r.h.dl = disk_car->disk;
  98.   switch(cmd)
  99.   {
  100.     case 2:
  101.       r.h.ah = 0x42;
  102.       break;
  103.     case 3:
  104.       r.x.ax = 0x4300;
  105.       dosmemput(buffer,xfer2,dos_segment2<<4);
  106.       break;
  107.     case 0x0C:
  108.       r.h.ah = 0x47;
  109.       break;
  110.   }
  111.   dosmemput(&buf, HD_RW_BUF_SIZ, dos_segment<<4);
  112.   __dpmi_int(0x13, &r);
  113.   if(cmd==2)
  114.     dosmemget(dos_segment2<<4, xfer2, buffer);
  115.   __dpmi_free_dos_memory(dos_selector2);
  116. #ifdef DEBUG
  117.   if(r.h.ah)
  118.   {
  119.     doprintf(" %ld err %02X %04X\n",*(dword*)&buf[0x8], r.h.ah,r.x.flags);
  120.   }
  121. #endif
  122.   return r.h.ah;
  123. }
  124.  
  125. int check_enh_bios(t_param_disk param_disk, const int debug)
  126. {
  127.   __dpmi_regs r;
  128.   r.h.ah = 0x41;
  129.   r.x.bx = 0x55AA;
  130.   r.h.dl = param_disk->disk;
  131.   __dpmi_int(0x13, &r);
  132.   if(r.x.bx != 0xAA55)  /* INT 13 Extensions not installed */
  133.     return 0;
  134.   if(debug)
  135.   {
  136.     printf("Disk %02X\n",param_disk->disk);
  137.     switch(r.h.ah)
  138.     {
  139.       case 0x01:
  140.         printf("Enhanced BIOS 1.x\n");
  141.         break;
  142.       case 0x20:
  143.         printf("Enhanced BIOS 2.0 / EDD-1.0\n");
  144.         break;
  145.       case 0x21:
  146.         printf("Enhanced BIOS 2.1 / EDD-1.1\n");
  147.         break;
  148.       case 0x30:
  149.         printf("Enhanced BIOS EDD-3.0\n");
  150.         break;
  151.       default:
  152.         printf("Enhanced BIOS unknow %02X\n",r.h.ah);
  153.         break;
  154.     }
  155.     if((r.x.cx & 1)!=0)
  156.       printf("Extended disk access functions R/W/I Ok\n");
  157.     if((r.x.cx & 4)!=0)
  158.       printf("Enhanced disk drive (EDD) functions identify Ok\n");
  159.   }
  160.   return ((r.x.cx&1)!=0);
  161. }
  162.  
  163. int hd_identify_enh_bios(t_param_disk param_disk)
  164. {
  165.   __dpmi_regs r;
  166.   uchar buf[HDPARM_BUF_SIZ];
  167.   buf[0]=HDPARM_BUF_SIZ;
  168.   buf[1]=0;
  169.   if(dos_segment==0)
  170.     if(alloc_dos_buffer())
  171.       return 1;
  172.   r.h.ah = 0x48;
  173.   r.x.ds = dos_segment;
  174.   r.x.si = 0;
  175.   r.h.dl = param_disk->disk;
  176.   dosmemput(&buf, HDPARM_BUF_SIZ, dos_segment<<4);
  177.   __dpmi_int(0x13, &r);
  178.   dosmemget(dos_segment<<4, HDPARM_BUF_SIZ, &buf);
  179.   if(r.h.ah)
  180.     return 1;
  181.   param_disk->CHS.cylinder=*(word*)&buf[0x04];
  182.   param_disk->CHS.head=*(word*)&buf[0x08];
  183.   param_disk->CHS.sector=*(word*)&buf[0x0C];
  184.   if(param_disk->CHS.cylinder)
  185.   {
  186.     param_disk->CHS.cylinder--;
  187.     param_disk->CHS.head--;
  188.   }
  189.   else
  190.   {   /* ATTENTION qword en fait */
  191.     param_disk->CHS.cylinder=(*(dword*)&buf[0x10]/255)/63-1;
  192.     param_disk->CHS.head=255-1;
  193.     param_disk->CHS.sector=63;
  194.   }
  195. #ifdef DEBUG
  196.   printf("hd_identify_enh_bios\n");
  197. #endif
  198. //  aff_disk_rapport(param_disk);
  199.   return 0;
  200. }
  201.  
  202. int hd_identify_bios(t_param_disk param_disk)
  203. {
  204.   uchar buf[0x200];
  205.   if(biosdisk(PARA_CMD,param_disk->disk,0,0,1,1,buf))
  206.     return 1;
  207.   param_disk->CHS.cylinder=((buf[0] & 0x0C0)<<2)|buf[1];
  208.   param_disk->CHS.head=buf[3];
  209.   param_disk->CHS.sector=buf[0] & 0x3F;
  210. #ifdef DEBUG
  211.   printf("hd_identify_bios\n");
  212. #endif
  213. //  aff_disk_rapport(param_disk);
  214.   return 0;
  215. }
  216.  
  217. int hd_identify(t_param_disk param_disk, const int debug)
  218. {
  219.   int err=1;
  220.   param_disk->mode=check_enh_bios(param_disk,debug);
  221.   if(!hd_identify_bios(param_disk))
  222.   {
  223.     err=0;
  224.     if(!biosdisk(0x0C, param_disk->disk, param_disk->CHS.head, param_disk->CHS.cylinder+1, param_disk->CHS.sector, 0, NULL))
  225.     {
  226.       param_disk->CHS.cylinder++;
  227.       if(debug)
  228.         printf("BIOS hides the last sector.\n");
  229.     }
  230.   }
  231.   if(param_disk->mode)
  232.     return hd_identify_enh_bios(param_disk);
  233.   return err;
  234. }
  235.  
  236. int hd_read(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_disk_cst lieu)
  237. {
  238.   int i,rc=-1;
  239.   for(i=0;(rc!=0) && (i<MAX_IO_NBR);i++)
  240.     rc=hd_super(2, disk_car, lieu->head, lieu->cylinder, lieu->sector, nbr_secteur, nom_buffer);
  241.   /*
  242.   for(i=0;i<0x10;i++)
  243.     printf("%02X ",*(char*)(nom_buffer+i));
  244.   printf("\n");
  245.   fflush(stdout);
  246.   */
  247.   return rc;
  248. }
  249.  
  250. int hd_read2(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_diskext_cst lieu)
  251. {
  252.   int i,rc=-1;
  253.   for(i=0;(rc!=0) && (i<MAX_IO_NBR);i++)
  254.     rc=hd_super(2, disk_car, lieu->start.head, lieu->start.cylinder, lieu->start.sector, nbr_secteur, nom_buffer);
  255. #ifdef DEBUG
  256.   for(i=0;i<0x10;i++)
  257.     printf("%02X ",*(char*)(nom_buffer+i));
  258.   printf("\n");
  259.   fflush(stdout);
  260. #endif
  261.   return rc;
  262. }
  263.  
  264. int hd_write(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_disk_cst lieu)
  265. {
  266.   int i,rc=-1;
  267.   for(i=0;(rc!=0)&&(i<MAX_IO_NBR);i++)
  268.     rc=hd_super(3, disk_car, lieu->head, lieu->cylinder, lieu->sector, nbr_secteur, nom_buffer);
  269.   return rc;
  270. }
  271.  
  272. int hd_write2(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_diskext_cst lieu)
  273. {
  274.   int i,rc=-1;
  275.   for(i=0;(rc!=0)&&(i<MAX_IO_NBR);i++)
  276.     rc=hd_super(3, disk_car, lieu->start.head, lieu->start.cylinder, lieu->start.sector, nbr_secteur, nom_buffer);
  277.   return rc;
  278. }
  279.  
  280. int hd_parse(t_param_disk param_disk[NBR_DISK_MAX],const int debug)
  281. {
  282.   int i;
  283.   int nbr_disk=0;
  284.   for(i=0x80;i<0x88;i++)
  285.   {
  286.     param_disk[nbr_disk]->disk=i;
  287.     if(!hd_identify(param_disk[nbr_disk],debug))
  288.       nbr_disk++;
  289.   }
  290.   return nbr_disk;
  291. }
  292. #elif defined(LINUX)
  293. #include <unistd.h>
  294. #include <sys/ioctl.h>
  295. #include <linux/hdreg.h>
  296. #include <fcntl.h> 
  297. #include <sys/mount.h>
  298. #include <string.h>
  299. #include "types.h"
  300. #include "common.h"
  301. #include "fnctdsk.h"
  302. #include "hdaccess.h"
  303.  
  304. loff_t llseek(int,loff_t, int);
  305. /* if llseek don't work well, try lseek64 */
  306.  
  307. int hd_read(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_disk_cst lieu)
  308. {
  309.   int i;
  310.   loff_t pos;
  311.   pos=((loff_t) get_LBA(disk_car,lieu))<<9;
  312.   i=llseek(lieu->disk,pos,SEEK_SET);
  313.   if(i==-1)
  314.     return -1;
  315.   if(read(lieu->disk, nom_buffer, nbr_secteur*0x200)==-1)
  316.     return -1;
  317.   return 0;
  318. }
  319.  
  320. int hd_write(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_disk_cst lieu)
  321. {
  322. #ifdef LINUX_WRITE
  323.   int i;
  324.   loff_t pos;
  325.   pos=((loff_t) get_LBA(disk_car,lieu))<<9;
  326.   i=llseek(lieu->disk,pos,SEEK_SET);
  327.   if(i==-1)
  328.     return -1;
  329.   if(write(lieu->disk, nom_buffer, nbr_secteur*0x200)<0)
  330.     return -1;
  331.   return 0;
  332. #else
  333.   return 1;
  334. #endif
  335. }
  336.  
  337. int hd_read2(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_diskext_cst lieu)
  338. {
  339.   int i;
  340.   loff_t pos;
  341.   pos=((loff_t) get_LBA_part(disk_car,lieu))<<9;
  342.   i=llseek(lieu->disk,pos,SEEK_SET);
  343.   if(i==-1)
  344.     return -1;
  345.   read(lieu->disk, nom_buffer, nbr_secteur*0x200);
  346.   return 0;
  347. }
  348.  
  349. int hd_write2(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_diskext_cst lieu)
  350. {
  351. #ifdef LINUX_WRITE
  352.   int i;
  353.   loff_t pos;
  354.   pos=((loff_t) get_LBA_part(disk_car,lieu))<<9;
  355.   i=llseek(lieu->disk,pos,SEEK_SET);
  356.   if(i==-1)
  357.     return -1;
  358.   if(write(lieu->disk, nom_buffer, nbr_secteur*0x200)<0)
  359.     return -1;
  360.   return 0;
  361. #else
  362.   return 1;
  363. #endif
  364. }
  365.  
  366. void test_disk_availability(int * nbr_disk,t_param_disk param_disk[NBR_DISK_MAX], char *device);
  367. void test_disk_availability(int * nbr_disk,t_param_disk param_disk[NBR_DISK_MAX], char *device)
  368. {
  369.   struct hd_geometry geometry;
  370.   int hd_h = open(device, open_mode);
  371.   if(hd_h>0)
  372.   {
  373.     /* Little trick from Linux fdisk */
  374.     /* Blocks are visible in more than one way:
  375.        e.g. as block on /dev/hda and as block on /dev/hda3
  376.        By a bug in the Linux buffer cache, we will see the old
  377.        contents of /dev/hda when the change was made to /dev/hda3.
  378.        In order to avoid this, discard all blocks on /dev/hda. */
  379.     ioctl(hd_h, BLKFLSBUF);    /* ignore errors */
  380.                     /* e.g. Permission Denied */
  381.     if (!ioctl(hd_h, HDIO_GETGEO, &geometry))
  382.     { /* I can get the geometry */
  383.       param_disk[*nbr_disk]->name=MALLOC(strlen(device)+1);
  384.       strcpy(param_disk[*nbr_disk]->name,device);
  385.       param_disk[*nbr_disk]->CHS.cylinder= geometry.cylinders-1;
  386.       param_disk[*nbr_disk]->CHS.head=geometry.heads-1;
  387.       param_disk[*nbr_disk]->CHS.sector= geometry.sectors;
  388.       param_disk[*nbr_disk]->disk= hd_h;
  389.       (*nbr_disk)++;
  390.     }
  391.     else
  392.       close(hd_h);
  393.   }
  394. }
  395.  
  396. int hd_parse(t_param_disk param_disk[NBR_DISK_MAX],const int debug)
  397. {
  398.   int i;
  399.   char device_ide[]="/dev/hda";
  400.   char device_scsi[]="/dev/sda";
  401.   char device_ida[]="/dev/ida/c0d0";
  402.   int nbr_disk=0;
  403.   /* Disk IDE */
  404.   for(i=0;i<8;i++)
  405.   {
  406.     device_ide[strlen(device_ide)-1]='a'+i;
  407.     test_disk_availability(&nbr_disk,param_disk, device_ide);
  408.   }
  409.   /* Disk SCSI */
  410.   for(i=0;i<8;i++)
  411.   {
  412.     device_scsi[strlen(device_scsi)-1]='a'+i;
  413.     test_disk_availability(&nbr_disk,param_disk, device_scsi);
  414.   }
  415.   /* Device RAID Compaq */
  416.   test_disk_availability(&nbr_disk,param_disk, device_ida);
  417.   return nbr_disk;
  418. }
  419. #else
  420. #include <unistd.h>
  421. #include <sys/ioctl.h>
  422. #include <fcntl.h> 
  423. #include <sys/disklabel.h>
  424. #include "types.h"
  425. #include "common.h"
  426. #include "fnctdsk.h"
  427. #include "hdaccess.h"
  428.  
  429. int hd_read(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_disk_cst lieu)
  430. {
  431.   int i;
  432.   off_t pos;
  433.   pos=((off_t) get_LBA(disk_car,lieu))<<9;
  434.   printf("hd_read at %ld\n", pos);
  435.   i=lseek(lieu->disk,pos,SEEK_SET);
  436.   if(i==-1)
  437.     return -1;
  438.   if(read(lieu->disk, nom_buffer, nbr_secteur*0x200)==-1)
  439.     return -1;
  440.   return 0;
  441. }
  442.  
  443. int hd_write(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_disk_cst lieu)
  444. {
  445. #ifdef LINUX_WRITE
  446.   int i;
  447.   off_t pos;
  448.   pos=((off_t) get_LBA(disk_car,lieu))<<9;
  449.   i=lseek(lieu->disk,pos,SEEK_SET);
  450.   if(i==-1)
  451.     return -1;
  452.   if(write(lieu->disk, nom_buffer, nbr_secteur*0x200)<0)
  453.     return -1;
  454.   return 0;
  455. #else
  456.   return 1;
  457. #endif
  458. }
  459.  
  460. int hd_read2(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_diskext_cst lieu)
  461. {
  462.   int i;
  463.   off_t pos;
  464.   pos=((off_t) get_LBA_part(disk_car,lieu))<<9;
  465.   i=lseek(lieu->disk,pos,SEEK_SET);
  466.   if(i==-1)
  467.     return -1;
  468.   read(lieu->disk, nom_buffer, nbr_secteur*0x200);
  469.   return 0;
  470. }
  471.  
  472. int hd_write2(t_param_disk_cst disk_car,const uint nbr_secteur, void *nom_buffer, t_diskext_cst lieu)
  473. {
  474. #ifdef LINUX_WRITE
  475.   int i;
  476.   off_t pos;
  477.   pos=((off_t) get_LBA_part(disk_car,lieu))<<9;
  478.   i=lseek(lieu->disk,pos,SEEK_SET);
  479.   if(i==-1)
  480.     return -1;
  481.   if(write(lieu->disk, nom_buffer, nbr_secteur*0x200)<0)
  482.     return -1;
  483.   return 0;
  484. #else
  485.   return 1;
  486. #endif
  487. }
  488.  
  489. void test_disk_availability(int * nbr_disk,t_param_disk param_disk[NBR_DISK_MAX], char *device);
  490. void test_disk_availability(int * nbr_disk,t_param_disk param_disk[NBR_DISK_MAX], char *device)
  491. {
  492.   struct disklabel geometry;
  493.   int hd_h = open(device, open_mode);
  494.   if(hd_h>0)
  495.   {
  496.     if (!ioctl(hd_h, DIOCGDINFO, &geometry))
  497.     { /* I can get the geometry */
  498.       param_disk[*nbr_disk]->name=MALLOC(strlen(device)+1);
  499.       strcpy(param_disk[*nbr_disk]->name,device);
  500. /*
  501.       param_disk[*nbr_disk]->CHS.cylinder= geometry.cylinders-1;
  502.       param_disk[*nbr_disk]->CHS.head=geometry.heads-1;
  503.       param_disk[*nbr_disk]->CHS.sector= geometry.sectors;
  504.  */
  505.       param_disk[*nbr_disk]->CHS.cylinder=geometry.d_ncylinders-1;
  506.       param_disk[*nbr_disk]->CHS.head=geometry.d_ntracks-1;
  507.       param_disk[*nbr_disk]->CHS.sector=geometry.d_nsectors;
  508.       param_disk[*nbr_disk]->disk= hd_h;
  509.       (*nbr_disk)++;
  510.     }
  511.     else
  512.       close(hd_h);
  513.   }
  514. }
  515.  
  516. int hd_parse(t_param_disk param_disk[NBR_DISK_MAX],const int debug)
  517. {
  518.   int i;
  519.   char device_ide[]="/dev/rwd0";
  520.   char device_scsi[]="/dev/rda0";
  521.   char device_optdisk[]="/dev/rod0";
  522.   int nbr_disk=0;
  523.   /* Disk IDE */
  524.   for(i=0;i<8;i++)
  525.   {
  526.     device_ide[strlen(device_ide)-1]='0'+i;
  527.     test_disk_availability(&nbr_disk,param_disk, device_ide);
  528.   }
  529.   /* Disk SCSI */
  530.   for(i=0;i<8;i++)
  531.   {
  532.     device_scsi[strlen(device_scsi)-1]='0'+i;
  533.     test_disk_availability(&nbr_disk,param_disk, device_scsi);
  534.   }
  535.   /* optical disks */
  536.   for(i=0;i<8;i++)
  537.   {
  538.     device_optdisk[strlen(device_scsi)-1]='a'+i;
  539.     test_disk_availability(&nbr_disk,param_disk, device_optdisk);
  540.   } 
  541.   return nbr_disk;
  542. }
  543. #endif
  544.